home *** CD-ROM | disk | FTP | other *** search
/ Collection of Tools & Utilities / Collection of Tools and Utilities.iso / c / bisonpcb.zip / LEX.C < prev    next >
C/C++ Source or Header  |  1987-02-13  |  10KB  |  480 lines
  1. /* Token-reader for Bison's input parser,
  2.    Copyright (C) 1984, 1986 Bob Corbett and Free Software Foundation, Inc.
  3.   
  4. BISON is distributed in the hope that it will be useful, but WITHOUT ANY
  5. WARRANTY.  No author or distributor accepts responsibility to anyone
  6. for the consequences of using it or for whether it serves any
  7. particular purpose or works at all, unless he says so in writing.
  8. Refer to the BISON General Public License for full details.
  9.   
  10. Everyone is granted permission to copy, modify and redistribute BISON,
  11. but only under the conditions described in the BISON General Public
  12. License.  A copy of this license is supposed to have been given to you
  13. along with BISON so you can know your rights and responsibilities.  It
  14. should be in a file named COPYING.  Among other things, the copyright
  15. notice and this notice must be preserved on all copies.
  16.   
  17.  In other words, you are welcome to use, share and improve this program.
  18.  You are forbidden to forbid anyone else to use, share and improve
  19.  what you give them.   Help stamp out software-hoarding!  */
  20.  
  21. /* 
  22.    lex() is the entry point.  It is called from reader.c.
  23.    It returns one of the token-type codes defined in lex.h.
  24.    When an identifier is seen, the code IDENTIFIER is returned
  25.    and the name is looked up in the symbol table using symtab.c;
  26.    symval is set to a pointer to the entry found.  */
  27.  
  28. /*
  29.  * Port to PC by Whit Gregg
  30.  *               Nourse, Gregg & Browne, Inc.
  31.  *         1 Horizon Road
  32.  *         Fort Lee, NJ  07024
  33.  */
  34.  
  35.  
  36. #include <stdio.h>
  37. #include <ctype.h>
  38. #include <string.h>
  39. #include "files.h"
  40. #include "symtab.h"
  41. #include "lex.h"
  42. #include "func.h"
  43.  
  44.  
  45.     extern int lineno;
  46. extern int translations;
  47.  
  48.  
  49. char token_buffer[MAXTOKEN + 1];
  50. bucket *symval;
  51. int numval;
  52.  
  53. static int unlexed;        /* these two describe a token to be reread */
  54. static bucket *unlexed_symval;    /* by the next call to lex */
  55.  
  56.  
  57.  
  58. void 
  59. init_lex()
  60. {                /* WG */
  61.     unlexed = -1;
  62.     }
  63.  
  64.  
  65.  
  66. int
  67. skip_white_space()
  68. {
  69.     register int c;
  70.     register int inside;
  71.  
  72.     c = getc(finput);
  73.  
  74.     for (;;) {
  75.         switch (c) {
  76.             case '/':
  77.             c = getc(finput);
  78.             if (c != '*')
  79.                 fatals("unexpected '/%c' found", c);
  80.  
  81.             c = getc(finput);
  82.  
  83.             inside = 1;
  84.             while (inside) {
  85.                 if (c == '*') {
  86.                     while (c == '*')
  87.                         c = getc(finput);
  88.  
  89.                     if (c == '/') {
  90.                         inside = 0;
  91.                         c = getc(finput);
  92.                         }
  93.                     }
  94.                 else if (c == '\n') {
  95.                     lineno++;
  96.                     c = getc(finput);
  97.                     }
  98.                 else if (c == EOF)
  99.                     fatal("unterminated comment");
  100.                 else
  101.                     c = getc(finput);
  102.                 }
  103.  
  104.             break;
  105.  
  106.             case '\n':
  107.             lineno++;
  108.  
  109.             case ' ':
  110.             case '\t':
  111.             case '\f':
  112.             c = getc(finput);
  113.             break;
  114.  
  115.             default:
  116.             return (c);
  117.             }
  118.         }
  119.     }
  120.  
  121.  
  122.  
  123. void 
  124. unlex(token)            /* WG */
  125.     int token;
  126. {
  127.     unlexed = token;
  128.     unlexed_symval = symval;
  129.     }
  130.  
  131.  
  132.  
  133. int
  134. lex()
  135. {
  136.     register int c;
  137.     register char *p;
  138.  
  139.     if (unlexed >= 0) {
  140.         symval = unlexed_symval;
  141.         c = unlexed;
  142.         unlexed = -1;
  143.         return (c);
  144.         }
  145.  
  146.     c = skip_white_space();
  147.  
  148.     switch (c) {
  149.         case EOF:
  150.         return (ENDFILE);
  151.  
  152.         case 'A':
  153.         case 'B':
  154.         case 'C':
  155.         case 'D':
  156.         case 'E':
  157.         case 'F':
  158.         case 'G':
  159.         case 'H':
  160.         case 'I':
  161.         case 'J':
  162.         case 'K':
  163.         case 'L':
  164.         case 'M':
  165.         case 'N':
  166.         case 'O':
  167.         case 'P':
  168.         case 'Q':
  169.         case 'R':
  170.         case 'S':
  171.         case 'T':
  172.         case 'U':
  173.         case 'V':
  174.         case 'W':
  175.         case 'X':
  176.         case 'Y':
  177.         case 'Z':
  178.         case 'a':
  179.         case 'b':
  180.         case 'c':
  181.         case 'd':
  182.         case 'e':
  183.         case 'f':
  184.         case 'g':
  185.         case 'h':
  186.         case 'i':
  187.         case 'j':
  188.         case 'k':
  189.         case 'l':
  190.         case 'm':
  191.         case 'n':
  192.         case 'o':
  193.         case 'p':
  194.         case 'q':
  195.         case 'r':
  196.         case 's':
  197.         case 't':
  198.         case 'u':
  199.         case 'v':
  200.         case 'w':
  201.         case 'x':
  202.         case 'y':
  203.         case 'z':
  204.         case '.':
  205.         case '_':
  206.         p = token_buffer;
  207.         while (isalnum(c) || c == '_' || c == '.') {
  208.             if (p < token_buffer + MAXTOKEN)
  209.                 *p++ = (char) c;    /* WG */
  210.             c = getc(finput);
  211.             }
  212.  
  213.         *p = 0;
  214.         ungetc(c, finput);
  215.         symval = getsym(token_buffer);
  216.         return (IDENTIFIER);
  217.  
  218.         case '0':
  219.         case '1':
  220.         case '2':
  221.         case '3':
  222.         case '4':
  223.         case '5':
  224.         case '6':
  225.         case '7':
  226.         case '8':
  227.         case '9':
  228.         {
  229.             numval = 0;
  230.  
  231.             while (isdigit(c)) {
  232.                 numval = numval * 10 + c - '0';
  233.                 c = getc(finput);
  234.                 }
  235.             ungetc(c, finput);
  236.             return (NUMBER);
  237.             }
  238.  
  239.         case '\'':
  240.         translations = -1;
  241.  
  242.         /*
  243.          * parse the literal token and compute character code in 
  244.          * code  
  245.          */
  246.  
  247.         c = getc(finput);
  248.         {
  249.             register int code = 0;
  250.  
  251.             if (c == '\\') {
  252.                 c = getc(finput);
  253.  
  254.                 if (c <= '7' && c >= '0') {
  255.                     while (c <= '7' && c >= '0') {
  256.                         code = (code * 8) + (c - '0');
  257.                         c = getc(finput);
  258.                         }
  259.                     if (code >= 128 || code < 0)    /* JF this said
  260.                                      * if(c>=128) */
  261.                         fatals("malformatted literal token '\\%03o'", code);
  262.                     }
  263.                 else {
  264.                     if (c == 't')
  265.                         code = '\t';
  266.                     else if (c == 'n')
  267.                         code = '\n';
  268.                     else if (c == 'r')
  269.                         code = '\r';
  270.                     else if (c == 'f')
  271.                         code = '\f';
  272.                     else if (c == 'b')
  273.                         code = '\b';
  274.                     else if (c == '\\')
  275.                         code = '\\';
  276.                     else if (c == '\'')
  277.                         code = '\'';
  278.                     else if (c == '\"')    /* JF this is a good
  279.                                  * idea */
  280.                         code = '\"';
  281.                     else
  282.                         fatals("invalid literal token '\\%c'", c);
  283.                     c = getc(finput);
  284.                     }
  285.                 }
  286.             else {
  287.                 code = c;
  288.                 c = getc(finput);
  289.                 }
  290.             if (c != '\'')
  291.                 fatal("multicharacter literal tokens NOT supported");
  292.  
  293.             /*
  294.              * now fill token_buffer with the canonical name for
  295.              * this character as a literal token.  Do not use
  296.              * what the user typed, so that '\012' and '\n' can
  297.              * be interchangeable.  
  298.              */
  299.  
  300.             p = token_buffer;
  301.             *p++ = '\'';
  302.             if (code == '\\') {
  303.                 p = token_buffer + 1;
  304.                 *p++ = '\\';
  305.                 *p++ = '\\';
  306.                 }
  307.             else if (code == '\'') {
  308.                 p = token_buffer + 1;
  309.                 *p++ = '\\';
  310.                 *p++ = '\'';
  311.                 }
  312.             else if (code >= 040 && code != 0177)
  313.                 *p++ = (char) code;    /* WG */
  314.             else if (code == '\t') {
  315.                 p = token_buffer + 1;
  316.                 *p++ = '\\';
  317.                 *p++ = 't';
  318.                 }
  319.             else if (code == '\n') {
  320.                 p = token_buffer + 1;
  321.                 *p++ = '\\';
  322.                 *p++ = 'n';
  323.                 }
  324.             else if (code == '\r') {
  325.                 p = token_buffer + 1;
  326.                 *p++ = '\\';
  327.                 *p++ = 'r';
  328.                 }
  329.             else if (code == '\b') {
  330.                 p = token_buffer + 1;
  331.                 *p++ = '\\';
  332.                 *p++ = 'b';
  333.                 }
  334.             else if (code == '\f') {
  335.                 p = token_buffer + 1;
  336.                 *p++ = '\\';
  337.                 *p++ = 'f';
  338.                 }
  339.             else {
  340.                 *p++ = (char) (code / 0100 + '0');    /* WG */
  341.                 *p++ = (char) (((code / 010) & 07) + '0');    /* WG */
  342.                 *p++ = (char) ((code & 07) + '0');    /* WG */
  343.                 }
  344.             *p++ = '\'';
  345.             *p = 0;
  346.             symval = getsym(token_buffer);
  347.             symval->class = STOKEN;
  348.             if (!symval->user_token_number)
  349.                 symval->user_token_number = code;
  350.             return (IDENTIFIER);
  351.             }
  352.  
  353.         case ',':
  354.         return (COMMA);
  355.  
  356.         case ':':
  357.         return (COLON);
  358.  
  359.         case ';':
  360.         return (SEMICOLON);
  361.  
  362.         case '|':
  363.         return (BAR);
  364.  
  365.         case '{':
  366.         return (LEFT_CURLY);
  367.  
  368.         case '=':
  369.         c = getc(finput);
  370.         if (c == '{')
  371.             return (LEFT_CURLY);
  372.         else {
  373.             ungetc(c, finput);
  374.             return (ILLEGAL);
  375.             }
  376.  
  377.         case '<':
  378.         p = token_buffer;
  379.         c = getc(finput);
  380.         while (c != '>') {
  381.             if (c == '\n' || c == EOF)
  382.                 fatal("unterminated type name");
  383.  
  384.             if (p >= token_buffer + MAXTOKEN - 1)
  385.                 fatals("type name too long (%d max)", MAXTOKEN - 1);
  386.  
  387.             *p++ = (char) c;    /* WG */
  388.             c = getc(finput);
  389.             }
  390.         *p = 0;
  391.         return (TYPENAME);
  392.  
  393.  
  394.         case '%':
  395.         return (parse_percent_token());
  396.  
  397.         default:
  398.         return (ILLEGAL);
  399.         }
  400.     }
  401.  
  402.  
  403. /* parse a token which starts with %.  Assumes the % has already been read and discarded.  */
  404.  
  405. int
  406. parse_percent_token()
  407. {
  408.     register int c;
  409.     register char *p;
  410.  
  411.     p = token_buffer;
  412.     c = getc(finput);
  413.  
  414.     switch (c) {
  415.         case '%':
  416.         return (TWO_PERCENTS);
  417.